package com.dragon.modules.yuegou.query.member;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.dragon.modules.yuegou.entity.member.DistrictMemberEntity;
import com.dragon.modules.yuegou.mybatis.Condition;
import com.dragon.modules.yuegou.mybatis.Query;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonInclude.Include;
import com.fasterxml.jackson.annotation.JsonUnwrapped;

import java.time.LocalDateTime;

/**
 * 商圈会员 动态查询条件
 *
 * @author pbuilder generated
 * @date 2019-05-28 11:06:43
 * @version 2.0
 */
@JsonInclude(Include.NON_NULL)
public class DistrictMemberQuery extends DistrictMemberEntity implements Query<DistrictMemberEntity> {

	/** 查询条件 */
	@JsonUnwrapped(prefix = "id")
	private Condition<String> idCondition;

	/** 商圈ID查询条件 */
	@JsonUnwrapped(prefix = "busdId")
	private Condition<String> busdIdCondition;

	/** 会员ID查询条件 */
	@JsonUnwrapped(prefix = "memberId")
	private Condition<String> memberIdCondition;

	/** 会员积分查询条件 */
	@JsonUnwrapped(prefix = "memPoints")
	private Condition<Integer> memPointsCondition;

    /** 线下累计积分查询条件 */
	@JsonUnwrapped(prefix = "cumulativePoints")
	private Condition<Integer> cumulativePointsCondition;

    /** 线上累计积分查询条件 */
	@JsonUnwrapped(prefix = "onlinePoints")
	private Condition<Integer> onlinePointsCondition;

    /** 总积分查询条件 */
	@JsonUnwrapped(prefix = "totalPoints")
	private Condition<Integer> totalPointsCondition;

	/** 会员等级查询条件 */
	@JsonUnwrapped(prefix = "memLevel")
	private Condition<String> memLevelCondition;

	/** 等级有效期开始时间查询条件 */
	@JsonUnwrapped(prefix = "validityBeginTime")
	private Condition<LocalDateTime> validityBeginTimeCondition;

	/** 等级有效期结束时间查询条件 */
	@JsonUnwrapped(prefix = "validityEndTime")
	private Condition<LocalDateTime> validityEndTimeCondition;

	/** 累积签到天数查询条件 */
	@JsonUnwrapped(prefix = "signday")
	private Condition<Integer> signdayCondition;

	/** 粉丝数查询条件 */
	@JsonUnwrapped(prefix = "fansNum")
	private Condition<Integer> fansNumCondition;

	/** 查询条件 */
	@JsonUnwrapped(prefix = "createdTime")
	private Condition<LocalDateTime> createdTimeCondition;

	/** 查询条件 */
	@JsonUnwrapped(prefix = "modifiedTime")
	private Condition<LocalDateTime> modifiedTimeCondition;

	/** 查询条件 */
	@JsonUnwrapped(prefix = "version")
	private Condition<Integer> versionCondition;

	/**
	 * 构造一个查询条件对象
	 */
	public DistrictMemberQuery() {
		super();
	}

	/**
	 * 依据实体对象构造一个查询条件对象
	 *
	 * @param entity 实体对象
	 */
	public DistrictMemberQuery(DistrictMemberEntity entity) {
		super(entity);
	}

	/**
	 * 依据其它查询条件对象的信息构造一个查询条件对象
	 *
	 * @param other 查询条件对象
	 */
	public DistrictMemberQuery(DistrictMemberQuery other) {
		super(other);
		if(other.idCondition != null) {
			this.idCondition = other.idCondition.copy();
		}
		if(other.busdIdCondition != null) {
			this.busdIdCondition = other.busdIdCondition.copy();
		}
		if(other.memberIdCondition != null) {
			this.memberIdCondition = other.memberIdCondition.copy();
		}
		if(other.memPointsCondition != null) {
			this.memPointsCondition = other.memPointsCondition.copy();
		}
		if(other.cumulativePointsCondition != null) {
			this.cumulativePointsCondition = other.cumulativePointsCondition.copy();
		}
		if(other.onlinePointsCondition != null) {
			this.onlinePointsCondition = other.onlinePointsCondition.copy();
		}
		if(other.totalPointsCondition != null) {
			this.totalPointsCondition = other.totalPointsCondition.copy();
		}
		if(other.memLevelCondition != null) {
			this.memLevelCondition = other.memLevelCondition.copy();
		}
		if(other.validityBeginTimeCondition != null) {
			this.validityBeginTimeCondition = other.validityBeginTimeCondition.copy();
		}
		if(other.validityEndTimeCondition != null) {
			this.validityEndTimeCondition = other.validityEndTimeCondition.copy();
		}
		if(other.signdayCondition != null) {
			this.signdayCondition = other.signdayCondition.copy();
		}
		if(other.fansNumCondition != null) {
			this.fansNumCondition = other.fansNumCondition.copy();
		}
		if(other.createdTimeCondition != null) {
			this.createdTimeCondition = other.createdTimeCondition.copy();
		}
		if(other.modifiedTimeCondition != null) {
			this.modifiedTimeCondition = other.modifiedTimeCondition.copy();
		}
		if(other.versionCondition != null) {
			this.versionCondition = other.versionCondition.copy();
		}
	}

	@Override
	public QueryWrapper<DistrictMemberEntity> toQueryWrapper() {
		QueryWrapper<DistrictMemberEntity> wrapper = new QueryWrapper<>(this);
		if (idCondition != null) {
			idCondition.toWrapper(wrapper, COL_ID);
		}
		if (busdIdCondition != null) {
			busdIdCondition.toWrapper(wrapper, COL_BUSD_ID);
		}
		if (memberIdCondition != null) {
			memberIdCondition.toWrapper(wrapper, COL_MEMBER_ID);
		}
		if (memPointsCondition != null) {
			memPointsCondition.toWrapper(wrapper, COL_MEM_POINTS);
		}
		if (cumulativePointsCondition != null) {
			cumulativePointsCondition.toWrapper(wrapper, COL_CUMULATIVE_POINTS);
		}
		if (onlinePointsCondition != null) {
			onlinePointsCondition.toWrapper(wrapper, COL_ONLINE_POINTS);
		}
		if (totalPointsCondition != null) {
			totalPointsCondition.toWrapper(wrapper, COL_TOTAL_POINTS);
		}
		if (memLevelCondition != null) {
			memLevelCondition.toWrapper(wrapper, COL_MEM_LEVEL);
		}
		if (validityBeginTimeCondition != null) {
			validityBeginTimeCondition.toWrapper(wrapper, COL_VALIDITY_BEGIN_TIME);
		}
		if (validityEndTimeCondition != null) {
			validityEndTimeCondition.toWrapper(wrapper, COL_VALIDITY_END_TIME);
		}
		if (signdayCondition != null) {
			signdayCondition.toWrapper(wrapper, COL_SIGNDAY);
		}
		if (fansNumCondition != null) {
			fansNumCondition.toWrapper(wrapper, COL_FANS_NUM);
		}
		if (createdTimeCondition != null) {
			createdTimeCondition.toWrapper(wrapper, COL_CREATED_TIME);
		}
		if (modifiedTimeCondition != null) {
			modifiedTimeCondition.toWrapper(wrapper, COL_MODIFIED_TIME);
		}
		if (versionCondition != null) {
			versionCondition.toWrapper(wrapper, COL_VERSION);
		}
		return wrapper;
	}

	/**
	 * 构造并返回查询条件
	 *
	 * @return idCondition 查询条件
	 */
	public Condition<String> id() {
		this.idCondition = new Condition<>();
		return this.idCondition;
	}

	/**
	 * 获取查询条件
	 *
	 * @return idCondition 查询条件
	 */
	public Condition<String> getIdCondition() {
		return idCondition;
	}

	/**
	 * 设置查询条件
	 *
	 * @param idCondition 查询条件
	 */
	public void setIdCondition(Condition<String> idCondition) {
		this.idCondition = idCondition;
	}

	/**
	 * 构造并返回商圈ID查询条件
	 *
	 * @return busdIdCondition 商圈ID查询条件
	 */
	public Condition<String> busdId() {
		this.busdIdCondition = new Condition<>();
		return this.busdIdCondition;
	}

	/**
	 * 获取商圈ID查询条件
	 *
	 * @return busdIdCondition 商圈ID查询条件
	 */
	public Condition<String> getBusdIdCondition() {
		return busdIdCondition;
	}

	/**
	 * 设置商圈ID查询条件
	 *
	 * @param busdIdCondition 商圈ID查询条件
	 */
	public void setBusdIdCondition(Condition<String> busdIdCondition) {
		this.busdIdCondition = busdIdCondition;
	}

	/**
	 * 构造并返回会员ID查询条件
	 *
	 * @return memberIdCondition 会员ID查询条件
	 */
	public Condition<String> memberId() {
		this.memberIdCondition = new Condition<>();
		return this.memberIdCondition;
	}

	/**
	 * 获取会员ID查询条件
	 *
	 * @return memberIdCondition 会员ID查询条件
	 */
	public Condition<String> getMemberIdCondition() {
		return memberIdCondition;
	}

	/**
	 * 设置会员ID查询条件
	 *
	 * @param memberIdCondition 会员ID查询条件
	 */
	public void setMemberIdCondition(Condition<String> memberIdCondition) {
		this.memberIdCondition = memberIdCondition;
	}

	/**
	 * 构造并返回会员积分查询条件
	 *
	 * @return memPointsCondition 会员积分查询条件
	 */
	public Condition<Integer> memPoints() {
		this.memPointsCondition = new Condition<>();
		return this.memPointsCondition;
	}

	/**
	 * 获取会员积分查询条件
	 *
	 * @return memPointsCondition 会员积分查询条件
	 */
	public Condition<Integer> getMemPointsCondition() {
		return memPointsCondition;
	}

	/**
	 * 设置会员积分查询条件
	 *
	 * @param memPointsCondition 会员积分查询条件
	 */
	public void setMemPointsCondition(Condition<Integer> memPointsCondition) {
		this.memPointsCondition = memPointsCondition;
	}

	/**
	 * 构造并返回线下累计积分查询条件
	 * 
	 * @return cumulativePointsCondition 线下累计积分查询条件
	 */
	public Condition<Integer> cumulativePoints() {
		this.cumulativePointsCondition = new Condition<>();
		return this.cumulativePointsCondition;
	}
	
	/**
	 * 获取线下累计积分查询条件
	 * 
	 * @return cumulativePointsCondition 线下累计积分查询条件
	 */
	public Condition<Integer> getCumulativePointsCondition() {
		return cumulativePointsCondition;
	}

	/**
	 * 设置线下累计积分查询条件
	 * 
	 * @param cumulativePointsCondition 线下累计积分查询条件
	 */
	public void setCumulativePointsCondition(Condition<Integer> cumulativePointsCondition) {
		this.cumulativePointsCondition = cumulativePointsCondition;
	}

	/**
	 * 构造并返回线上累计积分查询条件
	 * 
	 * @return onlinePointsCondition 线上累计积分查询条件
	 */
	public Condition<Integer> onlinePoints() {
		this.onlinePointsCondition = new Condition<>();
		return this.onlinePointsCondition;
	}
	
	/**
	 * 获取线上累计积分查询条件
	 * 
	 * @return onlinePointsCondition 线上累计积分查询条件
	 */
	public Condition<Integer> getOnlinePointsCondition() {
		return onlinePointsCondition;
	}

	/**
	 * 设置线上累计积分查询条件
	 * 
	 * @param onlinePointsCondition 线上累计积分查询条件
	 */
	public void setOnlinePointsCondition(Condition<Integer> onlinePointsCondition) {
		this.onlinePointsCondition = onlinePointsCondition;
	}

	/**
	 * 构造并返回总积分查询条件
	 * 
	 * @return totalPointsCondition 总积分查询条件
	 */
	public Condition<Integer> totalPoints() {
		this.totalPointsCondition = new Condition<>();
		return this.totalPointsCondition;
	}
	
	/**
	 * 获取总积分查询条件
	 * 
	 * @return totalPointsCondition 总积分查询条件
	 */
	public Condition<Integer> getTotalPointsCondition() {
		return totalPointsCondition;
	}

	/**
	 * 设置总积分查询条件
	 * 
	 * @param totalPointsCondition 总积分查询条件
	 */
	public void setTotalPointsCondition(Condition<Integer> totalPointsCondition) {
		this.totalPointsCondition = totalPointsCondition;
	}

	/**
	 * 构造并返回会员等级查询条件
	 *
	 * @return memLevelCondition 会员等级查询条件
	 */
	public Condition<String> memLevel() {
		this.memLevelCondition = new Condition<>();
		return this.memLevelCondition;
	}

	/**
	 * 获取会员等级查询条件
	 *
	 * @return memLevelCondition 会员等级查询条件
	 */
	public Condition<String> getMemLevelCondition() {
		return memLevelCondition;
	}

	/**
	 * 设置会员等级查询条件
	 *
	 * @param memLevelCondition 会员等级查询条件
	 */
	public void setMemLevelCondition(Condition<String> memLevelCondition) {
		this.memLevelCondition = memLevelCondition;
	}

	/**
	 * 构造并返回等级有效期开始时间查询条件
	 *
	 * @return validityBeginTimeCondition 等级有效期开始时间查询条件
	 */
	public Condition<LocalDateTime> validityBeginTime() {
		this.validityBeginTimeCondition = new Condition<>();
		return this.validityBeginTimeCondition;
	}

	/**
	 * 获取等级有效期开始时间查询条件
	 *
	 * @return validityBeginTimeCondition 等级有效期开始时间查询条件
	 */
	public Condition<LocalDateTime> getValidityBeginTimeCondition() {
		return validityBeginTimeCondition;
	}

	/**
	 * 设置等级有效期开始时间查询条件
	 *
	 * @param validityBeginTimeCondition 等级有效期开始时间查询条件
	 */
	public void setValidityBeginTimeCondition(Condition<LocalDateTime> validityBeginTimeCondition) {
		this.validityBeginTimeCondition = validityBeginTimeCondition;
	}

	/**
	 * 构造并返回等级有效期结束时间查询条件
	 *
	 * @return validityEndTimeCondition 等级有效期结束时间查询条件
	 */
	public Condition<LocalDateTime> validityEndTime() {
		this.validityEndTimeCondition = new Condition<>();
		return this.validityEndTimeCondition;
	}

	/**
	 * 获取等级有效期结束时间查询条件
	 *
	 * @return validityEndTimeCondition 等级有效期结束时间查询条件
	 */
	public Condition<LocalDateTime> getValidityEndTimeCondition() {
		return validityEndTimeCondition;
	}

	/**
	 * 设置等级有效期结束时间查询条件
	 *
	 * @param validityEndTimeCondition 等级有效期结束时间查询条件
	 */
	public void setValidityEndTimeCondition(Condition<LocalDateTime> validityEndTimeCondition) {
		this.validityEndTimeCondition = validityEndTimeCondition;
	}

	/**
	 * 构造并返回累积签到天数查询条件
	 *
	 * @return signdayCondition 累积签到天数查询条件
	 */
	public Condition<Integer> signday() {
		this.signdayCondition = new Condition<>();
		return this.signdayCondition;
	}

	/**
	 * 获取累积签到天数查询条件
	 *
	 * @return signdayCondition 累积签到天数查询条件
	 */
	public Condition<Integer> getSigndayCondition() {
		return signdayCondition;
	}

	/**
	 * 设置累积签到天数查询条件
	 *
	 * @param signdayCondition 累积签到天数查询条件
	 */
	public void setSigndayCondition(Condition<Integer> signdayCondition) {
		this.signdayCondition = signdayCondition;
	}

	/**
	 * 构造并返回粉丝数查询条件
	 *
	 * @return fansNumCondition 粉丝数查询条件
	 */
	public Condition<Integer> fansNum() {
		this.fansNumCondition = new Condition<>();
		return this.fansNumCondition;
	}

	/**
	 * 获取粉丝数查询条件
	 *
	 * @return fansNumCondition 粉丝数查询条件
	 */
	public Condition<Integer> getFansNumCondition() {
		return fansNumCondition;
	}

	/**
	 * 设置粉丝数查询条件
	 *
	 * @param fansNumCondition 粉丝数查询条件
	 */
	public void setFansNumCondition(Condition<Integer> fansNumCondition) {
		this.fansNumCondition = fansNumCondition;
	}

	/**
	 * 构造并返回查询条件
	 *
	 * @return createdTimeCondition 查询条件
	 */
	public Condition<LocalDateTime> createdTime() {
		this.createdTimeCondition = new Condition<>();
		return this.createdTimeCondition;
	}

	/**
	 * 获取查询条件
	 *
	 * @return createdTimeCondition 查询条件
	 */
	public Condition<LocalDateTime> getCreatedTimeCondition() {
		return createdTimeCondition;
	}

	/**
	 * 设置查询条件
	 *
	 * @param createdTimeCondition 查询条件
	 */
	public void setCreatedTimeCondition(Condition<LocalDateTime> createdTimeCondition) {
		this.createdTimeCondition = createdTimeCondition;
	}

	/**
	 * 构造并返回查询条件
	 *
	 * @return modifiedTimeCondition 查询条件
	 */
	public Condition<LocalDateTime> modifiedTime() {
		this.modifiedTimeCondition = new Condition<>();
		return this.modifiedTimeCondition;
	}

	/**
	 * 获取查询条件
	 *
	 * @return modifiedTimeCondition 查询条件
	 */
	public Condition<LocalDateTime> getModifiedTimeCondition() {
		return modifiedTimeCondition;
	}

	/**
	 * 设置查询条件
	 *
	 * @param modifiedTimeCondition 查询条件
	 */
	public void setModifiedTimeCondition(Condition<LocalDateTime> modifiedTimeCondition) {
		this.modifiedTimeCondition = modifiedTimeCondition;
	}

	/**
	 * 构造并返回查询条件
	 *
	 * @return versionCondition 查询条件
	 */
	public Condition<Integer> version() {
		this.versionCondition = new Condition<>();
		return this.versionCondition;
	}

	/**
	 * 获取查询条件
	 *
	 * @return versionCondition 查询条件
	 */
	public Condition<Integer> getVersionCondition() {
		return versionCondition;
	}

	/**
	 * 设置查询条件
	 *
	 * @param versionCondition 查询条件
	 */
	public void setVersionCondition(Condition<Integer> versionCondition) {
		this.versionCondition = versionCondition;
	}


	private String day;

	private String month;

	public String getDay() {
		return day;
	}

	public void setDay(String day) {
		this.day = day;
	}

	public String getMonth() {
		return month;
	}

	public void setMonth(String month) {
		this.month = month;
	}
}
